package com.cykj.user.service.impl;

import com.cykj.common.core.exception.ServiceException;
import com.cykj.user.domain.CtBan;
import com.cykj.user.domain.Customer;
import com.cykj.user.mapper.CtBanMapper;
import com.cykj.user.mapper.CustomerMapper;
import com.cykj.user.service.ICtService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.Date;
import java.util.List;

/**
 * @BelongsProject: Cykj-Order-System
 * @BelongsPackage: com.cykj.user.service.impl
 * @Author: 阿强
 * @CreateTime: 2025-08-18 11:33
 * @Description: 用户Service业务层处理
 * @Version: 1.0
 */
@Service
public class CtServiceImpl implements ICtService {
    @Autowired
    private CustomerMapper ctMapper;
    @Autowired
    private CtBanMapper ctBanMapper;

    @Autowired
    private CustomerMapper customerMapper;

    /**
     * 查询用户
     */
    @Override
    public Customer selectCtById(Long id) {
        if (id == null || id <= 0) {
            throw new ServiceException("用户ID不能为空或无效");
        }
        return ctMapper.selectById(Math.toIntExact(id));
    }

    /*** 查询用户列表*/
    @Override
    public List<Customer> selectCtList(Customer ct) {
        // 处理查询条件默认值，如状态默认查询正常用户
        if (ct == null) {
            ct = new Customer();
        }
        return ctMapper.selectCtList(ct);
    }

    /**
     * 新增用户
     */
    @Override
    public int insertCt(Customer ct) {
        validateCustomerInfo(ct, true);
        // 设置默认值
        if (ct.getIsBlacklisted() == null) {
            ct.setIsBlacklisted(0); // 默认未拉黑
        }
        if (ct.getStatus() == null) {
            ct.setStatus(1); // 默认状态正常
        }
        ct.setCreateTime(new Date());
        return ctMapper.insertCt(ct);
    }

    /**
     * 修改用户
     */
    @Override
    public int updateCt(Customer ct) {
        if (ct.getId() == null) {
            throw new ServiceException("用户ID不能为空");
        }
        validateCustomerInfo(ct, false);
        return ctMapper.updateCt(ct);
    }

    /**
     * 将用户加入黑名单操作结果（1-成功，0-失败）
     *
     * @param ctBan 封禁信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addUserToBlacklist(CtBan ctBan) {
        // 1. 校验参数（用户ID、封禁原因等）
        if (ctBan == null || ctBan.getCustomerId() == null) {
            return 0; // 参数错误返回失败
        }
        if (!StringUtils.hasText(ctBan.getReason())) {
            return 0; // 封禁原因不能为空
        }

        // 2. 检查用户是否存在
        Customer customer = customerMapper.selectById(ctBan.getCustomerId().intValue());
        if (customer == null) {
            return 0; // 用户不存在返回失败
        }

        // 3. 检查用户是否已在黑名单
        if (customer.getIsBlacklisted() == 1) {
            return 1; // 已在黑名单，视为成功（避免重复操作）
        }

        // 4. 更新用户表中的黑名单状态（is_blacklisted = 1）
        customer.setIsBlacklisted(1); // 1表示拉黑
        int updateCount = customerMapper.updateCt(customer);

        if (updateCount > 0) {
            // 5. 记录封禁信息到ct_ban表
            ctBan.setTime(new Date()); // 设置当前时间为封禁时间
            ctBan.setName(customer.getName()); // 补充用户名信息
            // 补充处罚内容默认值
            if (!StringUtils.hasText(ctBan.getContent())) {
                ctBan.setContent("系统自动封禁");
            }
            return ctBanMapper.insertCtBan(ctBan) > 0 ? 1 : 0; // 返回操作结果
        }
        return 0; // 用户状态更新失败则返回0
    }

    @Override
    public int addToBlacklist(CtBan ctBan) {
        // 直接调用上面的拉黑逻辑，避免重复代码
        return addUserToBlacklist(ctBan);
    }

    /**
     * 将用户从黑名单移除
     *
     * @param userId 用户ID
     * @return 1-成功，0-失败
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int removeUserFromBlacklist(Long userId) {
        // 1. 校验参数
        if (userId == null || userId <= 0) {
            return 0; // 参数错误返回失败
        }

        // 2. 检查用户是否存在
        Customer customer = customerMapper.selectById(userId.intValue());
        if (customer == null) {
            return 0; // 用户不存在返回失败
        }

        // 3. 检查用户是否处于拉黑状态
        if (customer.getIsBlacklisted() != 1) {
            return 1; // 非拉黑状态，视为成功（避免重复操作）
        }

        // 4. 更新用户表中的黑名单状态（is_blacklisted = 0）
        customer.setIsBlacklisted(0); // 0表示解除拉黑
        int updateCount = customerMapper.updateCt(customer);

        if (updateCount > 0) {
            // 5. 删除该用户的所有封禁记录
            CtBan queryBan = new CtBan();
            queryBan.setCustomerId(userId);
            List<CtBan> banList = ctBanMapper.selectCtBanList(queryBan);

            if (!banList.isEmpty()) {
                // 批量删除该用户的所有封禁记录
                Long[] banIds = banList.stream()
                        .map(CtBan::getId)
                        .toArray(Long[]::new);
                ctBanMapper.deleteCtBanByIds(banIds);
            }
            return 1; // 操作成功
        }
        return 0; // 用户状态更新失败
    }

    /**
     * 校验用户信息
     * @param customer 用户实体
     * @param isInsert 是否为新增操作
     */
    private void validateCustomerInfo(Customer customer, boolean isInsert) {
        if (isInsert && !StringUtils.hasText(customer.getTelephone())) {
            throw new ServiceException("用户手机号不能为空");
        }
        if (isInsert && !StringUtils.hasText(customer.getPassword())) {
            throw new ServiceException("用户密码不能为空");
        }
        // 手机号格式校验（简单示例）
        if (StringUtils.hasText(customer.getTelephone())
                && !customer.getTelephone().matches("^1[3-9]\\d{9}$")) {
            throw new ServiceException("手机号格式不正确");
        }
    }
}